Keyset pagination for performance in Rest API - Step-by-Step Execution

Concept Flow - Keyset pagination for performance

Client requests first page

↓

Server returns first N items + last item's key

↓

Client stores last item's key

↓

Client requests next page with last key

↓

Server returns next N items where key > last key

↓

Repeat until no more items

↓

End

The client requests pages using the last item's key from the previous page to fetch the next set efficiently.

Execution Sample

Rest API

GET /items?limit=3
Response: items with keys 1,2,3 + last_key=3

GET /items?limit=3&after=3
Response: items with keys 4,5,6 + last_key=6

Shows how client requests pages with limit and after key to get next items efficiently.

Execution Table

Step	Request URL	Server Query Condition	Items Returned (keys)	Last Key Sent	Client Action
1	/items?limit=3	No condition (start from beginning)	[1, 2, 3]	3	Store last_key=3
2	/items?limit=3&after=3	key > 3	[4, 5, 6]	6	Store last_key=6
3	/items?limit=3&after=6	key > 6	[7, 8]	8	Store last_key=8
4	/items?limit=3&after=8	key > 8	[]	-	No more items, stop

💡 No more items after key 8, server returns empty list, pagination ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
last_key	null	3	6	8	8
items_returned	[]	[1,2,3]	[4,5,6]	[7,8]	[]

Key Moments - 3 Insights

Why does the client send the 'after' key in the request?

The 'after' key tells the server where to start the next page, so it only returns items with keys greater than that, avoiding duplicates and improving performance (see execution_table steps 2 and 3).

What happens if the server returns fewer items than the limit?

It means there are no more items to fetch, so pagination ends (see execution_table step 3 and 4 where fewer or no items are returned).

Why is keyset pagination faster than offset pagination?

Because the server uses the last key to jump directly to the next items without scanning or skipping rows, making queries faster especially on large datasets.

Visual Quiz - 3 Questions

Look at the execution_table, what is the last_key stored by the client after step 2?

A 6

B 3

C 8

D null

💡 Hint

Check the 'Last Key Sent' column in execution_table row for step 2.

At which step does the server return no items, indicating the end of pagination?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look for the row where 'Items Returned' is empty in the execution_table.

If the client did not send the 'after' key in step 3, what would happen?

A Server returns items with keys > 8

B Server returns no items

C Server returns items starting from key 1 again

D Server returns an error

💡 Hint

Refer to execution_table step 1 where no 'after' key means start from beginning.

Concept Snapshot

Keyset pagination uses the last item's key to fetch the next page.
Client sends 'after' key to server.
Server returns items with keys greater than 'after'.
Faster than offset pagination for large data.
Stops when server returns fewer items than limit.

Full Transcript

Keyset pagination helps fetch data pages efficiently by using the last item's key from the previous page. The client first requests a page with a limit. The server returns items and the last key. The client stores this key and sends it in the next request as 'after'. The server then returns items with keys greater than this 'after' key. This repeats until no more items are left. This method avoids scanning or skipping rows, making it faster than offset pagination, especially for large datasets.