Review · August 26, 2026
Cursor-Based Pagination for Multi-Valued Attributes in SCIM
draft-kushwaha-scim-attr-cursor-pagination-00 — Saurabh Kushwaha (Oracle), submitted 8 April 2026. Individual submission, intended status Informational.
The Problem Statement
A group has 5,000 members. You do GET /Groups/{id} and the server hands you all 5,000 in one response.
SCIM paginates lists of resources. It does not paginate the array inside a single resource. So members, roles, and entitlements come back whole or not at all, and at enterprise scale "whole" means a payload nobody wants to build, transfer, or parse.
This draft adds two query parameters and a response block. Clients send attributeCount and attributeCursor. Servers return a slice of the attribute plus a membersPagination object with the total, the page size, the next cursor, and a hasMore flag.
That's the entire document. Four pages.
How the Spec Fits In
The problem is real, and it's chartered. The SCIM working group charter lists "Multi-Value Query Filtering and Paging" as explicit scope for the RFC 7643/7644 revision, and it names the input document: draft-hunt-scim-mv-paging.
The draft doesn't cite that document. It also doesn't cite the two other pieces of work that overlap it.
RFC 9865 already did cursor pagination for SCIM. Cursor-Based Pagination of SCIM Resources was published in October 2025, six months before this draft. It defines cursor and count as query parameters, nextCursor and previousCursor as response attributes, three new scimType error keywords for bad and expired cursors, and a pagination complex attribute on /ServiceProviderConfig so clients can discover support. This draft invents attributeCursor, attributeCount, nextCursor, hasMore, and no discovery mechanism at all. Two vocabularies for the same concept in the same protocol.
Phil Hunt's work already designed the multi-valued case. draft-hunt-scim-mv-filtering (2021), which superseded the mv-paging draft the charter names, puts qualifiers inside the existing attributes parameter using bracket syntax: attributes=*,members[type eq "Group"&count=5&startIndex=1]. It reports counts as a meta sub-attribute, members.cnt. It adds an mvpaging boolean to /ServiceProviderConfig. Both drafts are expired, but the design is the charter's starting point, and it solves a problem this draft has (more on that below). The original mv-paging draft was written by Phil Hunt and Gregg Wilson, both at Oracle at the time.
Danny Zollner is attacking the same problem from the other end. draft-zollner-scim-group-members flattens group membership into a top-level GroupMember resource type. Once membership is a resource, every existing SCIM feature works on it for free: index pagination, RFC 9865 cursors, filter, sortBy. No new pagination mechanism required. That draft cites payloads over 100MB and notes that many major SCIM implementations have simply given up on returning members at all.
So there are three live approaches to one chartered problem, and this draft engages with none of them.
On dependencies, it has exactly one normative reference: RFC 7644. That's too few, not too many. Adding attributes to a resource representation is RFC 7643 territory, and the draft never says it updates either document. Intended status is Informational, but the text is full of MUST, MUST NOT, SHOULD, and MAY with no BCP 14 boilerplate and no Notational Conventions section.
High-Level Summary
Here's what changes for the players involved.
Today a client that wants a big group's membership has two options. Ask for the group and accept whatever the server does, which in practice is often a timeout or a truncated list with no indication it was truncated. Or reverse the query and ask GET /Users?filter=groups.value eq "group-123"&count=100, which does paginate, because now you're paginating a list of resources instead of an array. Support for that filter varies by implementation, and it doesn't help for roles or entitlements.
This draft's proposal keeps the group-centric request and slices the array. The server gets to stream from its backend instead of materializing the whole membership list. The client gets a bounded response and a token to come back for more. Cursor rather than offset, which is the right call: if someone joins the group between page 3 and page 4, offset pagination silently skips or duplicates a member, and cursors don't.
The direction is correct. Three things about the execution should concern anyone evaluating this.
One cursor, many attributes. A User resource has roles, entitlements, emails, groups, phoneNumbers, and more. attributeCursor is a single flat parameter with nothing in it that identifies which attribute it belongs to. Send GET /Users/{id}?attributes=roles,entitlements&attributeCount=100 and there is no defined answer to what happens. Does attributeCount apply to both? Can you page them independently? The cursor is opaque, so a server could encode the attribute name inside it, but then the client can't construct a first request for the second attribute. Hunt's bracket syntax handled this in 2019 by attaching the qualifiers to each attribute. This draft's parameters can't express it.
You can delete 4,900 people from a group by accident. The example response is a Group resource with "id": "group-123" and one member in it. Nothing in the document says that response is a partial representation, or that a client MUST NOT write it back. The read-modify-write cycle is the most common client pattern in provisioning. A client that GETs a group, changes the display name, and PUTs the result has just replaced a 5,000-member group with a 100-member group. RFC 7644 §3.5.1 is explicit that PUT replaces the resource. This is the single most important thing missing from the draft, and it's a one-paragraph fix.
No way to find out if it works. A client has no signal that a server supports attribute-level pagination. Send attributeCount=100 to a server that doesn't implement this and you get the full 5,000 members back, which is exactly the outcome you were trying to avoid, and you have no way to tell that's what happened. RFC 9865 added the pagination block to /ServiceProviderConfig for precisely this reason, including a maxPageSize and a cursorTimeout. Section 3.4's claim that "existing SCIM clients remain unaffected" is true and beside the point. New clients are the ones with the problem.
Significant Interoperability Concerns
The response attribute has no schema. membersPagination appears in a Group resource. It isn't in RFC 7643's Group schema, it has no extension URN, and there's no IANA registration. SCIM clients that validate against declared schemas will reject it. Worse, the name is generated by convention: presumably rolesPagination and entitlementsPagination, though the draft never says so. Convention-generated attribute names can't be registered or validated.
Ordering is undefined. Cursor pagination over a mutable collection requires a stable sort key, and the draft doesn't mention one. Two servers will pick different keys and clients will see different results.
There are no error semantics. What does a server return for a malformed cursor, an expired cursor, or a negative attributeCount? RFC 9865 defined invalidCursor, expiredCursor, and invalidCount for the resource-level case. This draft could reuse all three and defines none.
There's no default and no maximum for attributeCount. Nothing says what a server does when the client omits it, or when the client asks for a million.
The interaction with attributes and excludedAttributes is unspecified, as is the interaction with the POST /.search endpoint, PATCH operations on a paginated attribute, and whether attributeCursor and RFC 9865's cursor can appear in the same request when you're listing groups and paginating members at the same time. That last combination is not exotic. It's what a sync client does.
Mechanisms That Could Be Removed
hasMore is redundant. RFC 9865 signals the last page by omitting nextCursor, and this draft returns both. Two ways to answer the same question is a guaranteed source of implementations that disagree.
itemsPerPage echoes back the number the client already sent, unless the server clamped it, and the draft doesn't say what happens when the server clamps it.
totalResults deserves a hard look. Counting members of a million-member group is expensive on many backends, which is why RFC 9865 explicitly lets providers omit or estimate it. This draft lists total count in the abstract as a feature and makes it look mandatory. It should be optional.
Section 3.3 "Rationale" is one sentence of general API-design commentary. Section 5 "Implementation Considerations" restates §3.1's opacity requirement and adds "Servers SHOULD optimize backend queries," which isn't a specifiable behavior. Section 6 "Future Work" defers filtering and sorting, which is where most of the value is and where the charter item points. Cut all three and the document loses nothing.
Writing Quality
The prose is clean. Sentences are short and grammatical, the problem statement in Section 2 is well organized, and there's no padding. As writing, this is better than a lot of what shows up in the individual-draft pile.
As an Internet-Draft, it's not finished. There's no Table of Contents, no Notational Conventions section, no BCP 14 reference despite heavy use of MUST and SHOULD, no Discussion Venues section, and no split between normative and informative references. The header is missing the working group line. The expiry date is "October 2026" with no day. The RFC 7644 citation uses "Hunt, P., et al." rather than the standard reference format. This does not look like it went through xml2rfc, which means the boilerplate problems are all mechanical and easy to fix.
The bigger problem is the other direction. At four pages this is too short to specify a protocol change. Section 3.1 introduces two query parameters in six lines: no ABNF, no encoding rules, no defaults, no bounds, no errors, no interaction with existing parameters. Section 3.2 shows a JSON example and never states the normative rules the example illustrates. An implementer reading this document and an implementer reading RFC 9865 will not produce compatible code, and two implementers reading only this document won't either.
Compare the Security Considerations, which is two sentences, against RFC 9865's treatment of cursor tampering and cursor-scoped authorization. Cursors that encode position into a permissioned dataset are a real access-control surface. "Cursor tokens SHOULD be tamper-resistant and scoped appropriately" names the concern without addressing it.
Background of the Author
Saurabh Kushwaha (Oracle) has published zero RFCs and has no expired Internet-Drafts. All four of his active drafts are SCIM documents, all submitted in 2026:
draft-kushwaha-scim-tenant-resourcedraft-kushwaha-scim-didvc-bindingdraft-kushwaha-scim-agent-governancedraft-kushwaha-scim-attr-cursor-pagination
New author, writing quickly, staying in one working group. That last part is a good sign. The volume is the thing to watch: four -00 and -01 drafts in a few months, none adopted, and this one is the thinnest of the set. The agent governance draft is a substantially more developed document, with an explicit out-of-scope section and acknowledgments from working group regulars. This one reads like it was written before anyone looked at the existing work.
Suggested Feedback
The problem is worth solving and it's already on the charter. The useful feedback is about where the work should happen, not whether.
Ask the author to read RFC 9865 and rewrite against it. Reuse cursor, count, nextCursor, and the three scimType error keywords. Extend the /ServiceProviderConfig pagination object rather than adding no discovery at all. If the parameters need to be distinguishable from the resource-level ones, say why, and pick names that make the relationship obvious.
Point at draft-hunt-scim-mv-filtering and ask how the single-cursor design handles more than one multi-valued attribute in a request. The bracket syntax is the charter's designated input and it answers this question. If there's a reason to prefer flat parameters, that reason belongs in the document.
Point at draft-zollner-scim-group-members and ask the direct question: why paginate inside a resource at all, when flattening membership into its own resource type makes every existing SCIM feature work? Groups are the motivating example in both documents. The working group is going to have to choose between these approaches, and this draft should argue its side.
Ask what happens when a client writes back a partially-populated resource. Until that's answered, this mechanism is a data-loss bug waiting for a deployment.
The honest recommendation is that this shouldn't be a separate document. It's a proposal for the "Multi-Value Query Filtering and Paging" charter item, and it's about a quarter of the way to being one. Bring it to the list as input to that work rather than as a fourth parallel draft.