coder · jscottmiller · Aug 3, 2026 · Aug 6, 2026 · Aug 11, 2026 · Aug 11, 2026
diff --git a/cli/list.go b/cli/list.go
@@ -178,3 +178,7 @@ func QueryConvertWorkspaces[T any](ctx context.Context, client *codersdk.Client,
 	}
 	return converted, nil
 }
+
+// pageLimit is the number of rows requested per page when the CLI fetches a
+// list endpoint to exhaustion.
+const pageLimit = codersdk.MaxPaginationLimit
diff --git a/cli/templatepull.go b/cli/templatepull.go
@@ -62,7 +62,7 @@ func (r *RootCmd) templatePull() *serpent.Command {
 			{
 				// Determine the latest template version and compare with the
 				// active version. If they aren't the same, warn the user.
-				versions, err := client.TemplateVersionsByTemplate(ctx, codersdk.TemplateVersionsByTemplateRequest{
+				versions, err := allTemplateVersions(ctx, client, codersdk.TemplateVersionsByTemplateRequest{
 					TemplateID: template.ID,
 				})
 				if err != nil {

diff --git a/cli/templateversions.go b/cli/templateversions.go
@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"context"
 	"fmt"
 	"strings"
 	"time"
@@ -14,6 +15,24 @@ import (
 	"github.com/coder/serpent"
 )
 
+// allTemplateVersions fetches template versions page by page until a page
+// returns fewer rows than requested, which marks the end of the result set.
+func allTemplateVersions(ctx context.Context, client *codersdk.Client, req codersdk.TemplateVersionsByTemplateRequest) ([]codersdk.TemplateVersion, error) {
+	req.Limit = pageLimit
+	var versions []codersdk.TemplateVersion
+	for {
+		page, err := client.TemplateVersionsByTemplate(ctx, req)
+		if err != nil {
+			return nil, err
+		}
+		versions = append(versions, page...)
+		if len(page) < pageLimit {
+			return versions, nil
+		}
+		req.Offset += len(page)
+	}
+}
+
 func (r *RootCmd) templateVersions() *serpent.Command {
 	cmd := &serpent.Command{
 		Use:     "versions",
@@ -110,7 +129,7 @@ func (r *RootCmd) templateVersionsList() *serpent.Command {
 				IncludeArchived: includeArchived.Value(),
 			}
 
-			versions, err := client.TemplateVersionsByTemplate(inv.Context(), req)
+			versions, err := allTemplateVersions(inv.Context(), client, req)
 			if err != nil {
 				return xerrors.Errorf("get template versions by template: %w", err)
 			}

diff --git a/cli/userlist.go b/cli/userlist.go
@@ -48,12 +48,23 @@ func (r *RootCmd) userList() *serpent.Command {
 				req.Search = fmt.Sprintf("github_com_user_id:%d", githubUserID)
 			}
 
-			res, err := client.Users(inv.Context(), req)
-			if err != nil {
-				return err
+			// Fetch pages until a page returns fewer rows than requested,
+			// which marks the end of the result set.
+			req.Limit = pageLimit
+			users := []codersdk.User{}
+			for {
+				res, err := client.Users(inv.Context(), req)
+				if err != nil {
+					return err
+				}
+				users = append(users, res.Users...)
+				if len(res.Users) < pageLimit {
+					break
+				}
+				req.Offset += len(res.Users)
 			}
 
-			out, err := formatter.Format(inv.Context(), res.Users)
+			out, err := formatter.Format(inv.Context(), users)
 			if err != nil {
 				return err
 			}

diff --git a/coderd/apidoc/docs.go b/coderd/apidoc/docs.go
diff --git a/coderd/apidoc/swagger.json b/coderd/apidoc/swagger.json
diff --git a/coderd/audit.go b/coderd/audit.go
@@ -37,7 +37,7 @@ const auditLogCountCap = 2000
 // @Produce json
 // @Tags Audit
 // @Param q query string false "Search query"
-// @Param limit query int true "Page limit"
+// @Param limit query int false "Page limit"
 // @Param offset query int false "Page offset"
 // @Success 200 {object} codersdk.AuditLogResponse
 // @Router /api/v2/audit [get]

diff --git a/coderd/members.go b/coderd/members.go
@@ -269,7 +269,7 @@ func (api *API) listMembers(rw http.ResponseWriter, r *http.Request) {
 // @Param organization path string true "Organization ID"
 // @Param q query string false "Member search query"
 // @Param after_id query string false "After ID" format(uuid)
-// @Param limit query int false "Page limit, if 0 returns all members"
+// @Param limit query int false "Page limit"
 // @Param offset query int false "Page offset"
 // @Success 200 {object} []codersdk.PaginatedMembersResponse
 // @Router /api/v2/organizations/{organization}/paginated-members [get]

diff --git a/coderd/pagination.go b/coderd/pagination.go
@@ -1,6 +1,7 @@
 package coderd
 
 import (
+	"fmt"
 	"net/http"
 
 	"github.com/google/uuid"
@@ -17,10 +18,22 @@ func ParsePagination(w http.ResponseWriter, r *http.Request) (p codersdk.Paginat
 	parser := httpapi.NewQueryParamParser()
 	params := codersdk.Pagination{
 		AfterID: parser.UUID(queryParams, uuid.Nil, "after_id"),
-		// A limit of 0 should be interpreted by the SQL query as "null" or
-		// "no limit". Do not make this value anything besides 0.
-		Limit:  int(parser.PositiveInt32(queryParams, 0, "limit")),
-		Offset: int(parser.PositiveInt32(queryParams, 0, "offset")),
+		Offset:  int(parser.PositiveInt32(queryParams, 0, "offset")),
+	}
+	limitErrsBefore := len(parser.Errors)
+	params.Limit = int(parser.PositiveInt32(queryParams, 0, "limit"))
+	limitParsed := len(parser.Errors) == limitErrsBefore
+	// An omitted limit resolves to codersdk.MaxPaginationLimit so the downstream
+	// query is never unbounded. A limit that is set must be a positive integer no
+	// greater than that maximum; otherwise it is rejected rather than clamped.
+	switch {
+	case queryParams.Get("limit") == "":
+		params.Limit = codersdk.MaxPaginationLimit
+	case limitParsed && (params.Limit < 1 || params.Limit > codersdk.MaxPaginationLimit):
+		parser.Errors = append(parser.Errors, codersdk.ValidationError{
+			Field:  "limit",
+			Detail: fmt.Sprintf("Query param \"limit\" must be a positive integer no greater than %d.", codersdk.MaxPaginationLimit),
+		})
 	}
 	if len(parser.Errors) > 0 {
 		httpapi.Write(ctx, w, http.StatusBadRequest, codersdk.Response{

diff --git a/coderd/pagination_test.go b/coderd/pagination_test.go
@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
+	"strconv"
 	"testing"
 
 	"github.com/google/uuid"
@@ -72,6 +73,11 @@ func TestPagination(t *testing.T) {
 			Offset:        "-1",
 			ExpectedError: invalidValues,
 		},
+		{
+			Name:          "LimitAboveMax",
+			Limit:         strconv.Itoa(codersdk.MaxPaginationLimit + 1),
+			ExpectedError: invalidValues,
+		},
 
 		// Valid values
 		{
@@ -93,11 +99,35 @@ func TestPagination(t *testing.T) {
 				Limit:   50,
 			},
 		},
+		{
+			// An omitted limit resolves to the maximum page size so the
+			// query is never unbounded.
+			Name: "DefaultsToMaxWhenAbsent",
+			ExpectedParams: codersdk.Pagination{
+				AfterID: uuid.Nil,
+				Limit:   codersdk.MaxPaginationLimit,
+			},
+		},
+		{
+			// An explicit limit must be positive; 0 is rejected.
+			Name:          "ZeroLimitRejected",
+			Limit:         "0",
+			ExpectedError: invalidValues,
+		},
+		{
+			Name:  "LimitAtMax",
+			Limit: strconv.Itoa(codersdk.MaxPaginationLimit),
+			ExpectedParams: codersdk.Pagination{
+				AfterID: uuid.Nil,
+				Limit:   codersdk.MaxPaginationLimit,
+			},
+		},
 		{
 			Name:   "ValidOffset",
 			Offset: "150",
 			ExpectedParams: codersdk.Pagination{
 				AfterID: uuid.Nil,
+				Limit:   codersdk.MaxPaginationLimit,
 				Offset:  150,
 			},
 		},
@@ -106,6 +136,7 @@ func TestPagination(t *testing.T) {
 			AfterID: "5f2005fc-acc4-4e5e-a7fa-be017359c60b",
 			ExpectedParams: codersdk.Pagination{
 				AfterID: uuid.MustParse("5f2005fc-acc4-4e5e-a7fa-be017359c60b"),
+				Limit:   codersdk.MaxPaginationLimit,
 			},
 		},
 	}

diff --git a/codersdk/pagination.go b/codersdk/pagination.go
@@ -7,6 +7,11 @@ import (
 	"github.com/google/uuid"
 )
 
+// MaxPaginationLimit is the largest page size the server accepts. An omitted
+// limit resolves to this value. A limit that is set must be a positive integer
+// no greater than this, so the resulting query is always bounded.
+const MaxPaginationLimit = 100
+
 // Pagination sets pagination options for the endpoints that support it.
 type Pagination struct {
 	// AfterID returns all or up to Limit results after the given
@@ -15,9 +20,11 @@ type Pagination struct {
 	// set AfterID to the last UUID returned by the previous
 	// request.
 	AfterID uuid.UUID `json:"after_id,omitempty" format:"uuid"`
-	// Limit sets the maximum number of users to be returned
-	// in a single page. If the limit is <= 0, there is no limit
-	// and all users are returned.
+	// Limit sets the maximum number of results returned in a single page.
+	// When set, it must be a positive integer no greater than
+	// MaxPaginationLimit, otherwise the request is rejected. A value of 0
+	// omits the query parameter entirely, and the server resolves the page
+	// size to MaxPaginationLimit.
 	Limit int `json:"limit,omitempty"`
 	// Offset is used to indicate which page to return. An offset of 0
 	// returns the first 'limit' number of users.

diff --git a/codersdk/workspaces.go b/codersdk/workspaces.go
@@ -633,7 +633,7 @@ func (c *Client) Workspaces(ctx context.Context, filter WorkspaceFilter) (Worksp
 }
 
 // WorkspacePageSize is the number of rows AllWorkspaces requests per page.
-const WorkspacePageSize = 100
+const WorkspacePageSize = MaxPaginationLimit
 
 // AllWorkspaces requests successive pages of workspaces matching the filter and
 // returns every row. Limit and Offset on the filter are ignored.

diff --git a/docs/reference/api/audit.md b/docs/reference/api/audit.md
diff --git a/docs/reference/api/enterprise.md b/docs/reference/api/enterprise.md
diff --git a/docs/reference/api/members.md b/docs/reference/api/members.md