Testing pagination in Postman - Build an Automation Script

Verify API pagination returns correct data and navigation

Preconditions (2)

Step 1: Send a GET request to /items?page=1&limit=5

Step 2: Verify the response status code is 200

Step 3: Verify the response body contains exactly 5 items

Step 4: Note the total number of items from the response metadata

Step 5: Send a GET request to /items?page=2&limit=5

Step 6: Verify the response status code is 200

Step 7: Verify the response body contains the next 5 items

Step 8: Verify that no items from page 1 appear on page 2

Step 9: Send a GET request to /items?page=lastPage&limit=5 where lastPage is calculated from total items

Step 10: Verify the response status code is 200

Step 11: Verify the response body contains the remaining items (less than or equal to 5)

Step 12: Send a GET request to /items?page=0&limit=5

Step 13: Verify the response status code is 400 or appropriate error code

Step 14: Send a GET request to /items?page=1&limit=0

Step 15: Verify the response status code is 400 or appropriate error code

✅ Expected Result: API returns correct paginated data for valid pages with correct status codes and errors for invalid page or limit values

Automation Requirements - Postman Tests (JavaScript)

Assertions Needed:

Status code is 200 for valid requests

Response body contains expected number of items

No duplicate items between pages

Status code is 400 for invalid page or limit values

Best Practices:

Use pm.expect for assertions

Parse JSON response safely

Use variables to store total items and calculate last page

Write clear and descriptive test names

Avoid hardcoding values except for test inputs

Automated Solution

Postman

pm.test('Status code is 200 for page 1', () => {
    pm.response.to.have.status(200);
});

const jsonData = pm.response.json();

pm.test('Response has 5 items for page 1', () => {
    pm.expect(jsonData.items.length).to.eql(5);
});

// Store total items count for later use
pm.environment.set('totalItems', jsonData.total);

// Store items from page 1 for comparison
pm.environment.set('page1Items', JSON.stringify(jsonData.items));

// Calculate last page
const limit = 5;
const totalItems = pm.environment.get('totalItems');
const lastPage = Math.ceil(totalItems / limit);
pm.environment.set('lastPage', lastPage);

// Additional tests for page 2 and last page should be in separate requests using these variables

// Example test for page 2 (to be run in a separate request):
/*
pm.test('Status code is 200 for page 2', () => {
    pm.response.to.have.status(200);
});
const page2Data = pm.response.json();
pm.test('Response has 5 items for page 2', () => {
    pm.expect(page2Data.items.length).to.eql(5);
});

const page1Items = JSON.parse(pm.environment.get('page1Items'));
const page2Items = page2Data.items;

pm.test('No duplicate items between page 1 and page 2', () => {
    const page1Ids = page1Items.map(item => item.id);
    const page2Ids = page2Items.map(item => item.id);
    const duplicates = page2Ids.filter(id => page1Ids.includes(id));
    pm.expect(duplicates.length).to.eql(0);
});
*/

// Tests for invalid page and limit values:
pm.test('Status code is 400 for invalid page 0', () => {
    pm.response.to.have.status(400);
});

pm.test('Status code is 400 for invalid limit 0', () => {
    pm.response.to.have.status(400);
});

This Postman test script checks the API pagination step-by-step.

First, it verifies the status code is 200 for a valid page 1 request.

Then it checks that exactly 5 items are returned as expected.

It saves the total number of items and the items from page 1 in environment variables for later use.

It calculates the last page number based on total items and limit.

Additional tests for page 2 and last page are shown as comments because they should be run in separate requests using the saved variables.

It also includes tests for invalid page and limit values expecting a 400 error status.

This approach uses best practices like pm.expect assertions, environment variables for sharing data between requests, and clear test names.

Common Mistakes - 4 Pitfalls

Not checking the status code before parsing the response body

Hardcoding page numbers and limits without using variables

Not verifying that items between pages do not overlap

Ignoring error cases like invalid page or limit values

Bonus Challenge

Now add data-driven testing with 3 different page and limit combinations to verify pagination works for various inputs

Show Hint

Practice

1. What is the main purpose of testing pagination in an API using Postman?

easy

A. To verify that users can navigate through pages and see correct data counts

B. To check if the API returns data in alphabetical order

C. To ensure the API response time is under 1 second

D. To test if the API supports multiple languages

Solution

1. Step 1: Understand pagination purpose

   Pagination testing ensures users can move through pages and see correct data on each page.

2. Step 2: Identify key verification points

   We check page numbers, item counts, and total items to confirm correct navigation.

3. Final Answer:

   To verify that users can navigate through pages and see correct data counts -> Option A

4. Quick Check:

   Pagination = navigation + correct data [OK]

Hint: Pagination tests check page navigation and item counts [OK]

Common Mistakes:

• Confusing pagination with sorting
• Focusing only on response time
• Ignoring total item count

2. Which Postman script snippet correctly checks if the current page number is 3 in the response JSON?

easy

A. pm.test('Page is 3', () => pm.expect(pm.response.page).to.eql(3));

B. pm.test('Page is 3', () => pm.expect(response.page).to.equal(3));

C. pm.test('Page is 3', () => pm.expect(pm.response.json().page).to.eql(3));

D. pm.test('Page is 3', () => pm.expect(json.page).to.eql(3));

Solution

1. Step 1: Access response JSON correctly

   Use pm.response.json() to parse the response body as JSON.

2. Step 2: Use correct assertion syntax

   pm.expect(...).to.eql(3) checks if the page value equals 3.

3. Final Answer:

   pm.test('Page is 3', () => pm.expect(pm.response.json().page).to.eql(3)); -> Option C

4. Quick Check:

   Use pm.response.json() + pm.expect() [OK]

Hint: Use pm.response.json() to parse JSON before assertions [OK]

Common Mistakes:

• Using undefined variables like response or json
• Accessing pm.response.page directly
• Using to.equal instead of to.eql in Postman

3. Given this Postman test script, what will be the test result if the response JSON is {"page":2,"per_page":5,"total":12,"data":[1,2,3,4,5]}?

pm.test('Check page and items', () => {
  const json = pm.response.json();
  pm.expect(json.page).to.eql(2);
  pm.expect(json.data.length).to.eql(json.per_page);
  pm.expect(json.total).to.be.above(10);
});

medium

A. Test fails because page is not 2

B. Test fails because total is not above 10

C. Test fails because data length does not match per_page

D. All tests pass

Solution

1. Step 1: Check page number assertion

   json.page is 2, expected 2, so this passes.

2. Step 2: Check data length equals per_page

   json.data.length is 5, json.per_page is 5, so this passes.

3. Step 3: Check total is above 10

   json.total is 12, which is above 10, so this passes.

4. Final Answer:

   All tests pass -> Option D

5. Quick Check:

   All assertions true = pass [OK]

Hint: Match data length with per_page and check total > 10 [OK]

Common Mistakes:

• Assuming total must equal per_page
• Confusing page number with index
• Ignoring data array length

4. You wrote this Postman test to check pagination but it always fails:

pm.test('Page is 1', () => {
  const json = pm.response.json();
  pm.expect(json.page).to.equal(1);
});

The response JSON is {"page":1,"per_page":10,"total":50}. What is the likely error?

medium

A. The assertion syntax is correct; failure is due to response mismatch

B. Using to.equal instead of to.eql causes failure

C. pm.response.json() is not called correctly

D. The response JSON does not contain page key

Solution

1. Step 1: Check assertion method

   to.equal and to.eql behave similarly for primitives; this is not the cause.

2. Step 2: Verify response JSON keys

   Response has page key with value 1, so JSON access is correct.

3. Step 3: Consider response mismatch

   If test fails, likely the actual response page value differs or test runs on wrong response.

4. Final Answer:

   The assertion syntax is correct; failure is due to response mismatch -> Option A

5. Quick Check:

   Assertion syntax correct; check response data [OK]

Hint: Check actual response data if assertion syntax looks correct [OK]

Common Mistakes:

• Confusing to.equal and to.eql for primitives
• Assuming JSON parsing failed
• Ignoring actual response content

5. You want to test that the API correctly handles the last page of pagination when total items are 23 and per_page is 5. Which Postman test script correctly verifies the last page number and item count on that page?

hard

A. pm.test('Last page check', () => {
const json = pm.response.json();
pm.expect(json.page).to.eql(json.total);
pm.expect(json.data.length).to.eql(json.per_page);
});

B. pm.test('Last page check', () => {
const json = pm.response.json();
const lastPage = Math.ceil(json.total / json.per_page);
pm.expect(json.page).to.eql(lastPage);
pm.expect(json.data.length).to.eql(json.total % json.per_page || json.per_page);
});

C. pm.test('Last page check', () => {
const json = pm.response.json();
pm.expect(json.page).to.eql(json.total % json.per_page);
pm.expect(json.data.length).to.eql(json.per_page);
});

D. pm.test('Last page check', () => {
const json = pm.response.json();
pm.expect(json.page).to.eql(json.total / json.per_page);
pm.expect(json.data.length).to.eql(json.per_page);
});

Solution

1. Step 1: Calculate last page number

   Last page = ceiling of total / per_page = ceil(23/5) = 5.

2. Step 2: Calculate expected items on last page

   Items on last page = total % per_page = 23 % 5 = 3 (if 0, use per_page).

3. Step 3: Verify page number and data length

   Check json.page equals lastPage and json.data.length equals expected items.

4. Final Answer:

   pm.test('Last page check', () => { const json = pm.response.json(); const lastPage = Math.ceil(json.total / json.per_page); pm.expect(json.page).to.eql(lastPage); pm.expect(json.data.length).to.eql(json.total % json.per_page || json.per_page); }); -> Option B

5. Quick Check:

   Last page = ceil(total/per_page), items = remainder or per_page [OK]

Hint: Use Math.ceil for last page and remainder for last page items [OK]

Common Mistakes:

• Using division without ceiling for last page
• Expecting full per_page items on last page always
• Confusing modulo result with page number