Response size in Postman - Deep Dive

Overview - Response size

What is it?

Response size is the amount of data sent back from a server after a request. It includes all the information like headers and the body content. In Postman, you can see the response size to understand how much data your API returns. This helps you check if the response is too large or too small for your needs.

Why it matters

Knowing the response size helps ensure your API is efficient and fast. Large responses can slow down applications and use more data, which can frustrate users. Without checking response size, you might miss performance problems or waste resources. It’s like carrying a heavy backpack when you only need a few items.

Where it fits

Before learning response size, you should understand basic API requests and responses. After this, you can learn about performance testing and optimizing APIs. Response size is a key part of measuring how well your API works in real situations.

Mental Model

Core Idea

Response size measures how much data the server sends back after your request, affecting speed and resource use.

Think of it like...

Imagine ordering a meal at a restaurant. The response size is like the size of your plate. A huge plate might be too much food and slow you down, while a tiny plate might leave you hungry.

┌───────────────┐
│   Client      │
│  (Postman)   │
└──────┬────────┘
       │ Request
       ▼
┌───────────────┐
│   Server      │
│  (API)       │
└──────┬────────┘
       │ Response (data + headers)
       ▼
┌───────────────┐
│ Response Size │
│  (bytes)     │
└───────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding API Response Basics

Concept: Learn what an API response is and what it contains.

When you send a request to an API, it sends back a response. This response has two main parts: headers (information about the response) and the body (the actual data you asked for). Postman shows you both parts clearly.

Result

You can see the response status, headers, and body in Postman after making a request.

Understanding the parts of a response is essential before measuring its size.

2

Foundation

What is Response Size Exactly?

Concept: Response size is the total amount of data sent back by the server, including headers and body.

In Postman, response size is shown in bytes. It counts everything the server sends back. This helps you know how heavy the response is for your app or user.

Result

Postman displays response size next to the response time after each request.

Knowing response size helps you judge if your API responses are too large or small.

3

Intermediate

How to Check Response Size in Postman

🤔Before reading on: Do you think response size includes only the body or both headers and body? Commit to your answer.

Concept: Learn where and how Postman shows response size and what it includes.

After sending a request in Postman, look at the bottom right corner of the response panel. You will see the response size displayed in bytes or kilobytes. This size includes both headers and body data.

Result

You can quickly see how much data your API returned for each request.

Knowing where to find response size in Postman makes it easy to monitor API performance.

4

Intermediate

Why Response Size Affects Performance

🤔Before reading on: Does a bigger response size always mean slower performance? Commit to your answer.

Concept: Understand the impact of response size on network speed and user experience.

Large response sizes take longer to download and use more bandwidth. This can slow down your app and frustrate users, especially on slow networks. Smaller responses are faster but might miss important data.

Result

You learn to balance response size for speed and completeness.

Understanding this tradeoff helps you design better APIs and tests.

5

Advanced

Measuring Response Size in Automated Tests

🤔Before reading on: Can you write a test in Postman to check if response size is under a limit? Commit to your answer.

Concept: Use Postman scripts to automatically check response size during testing.

In Postman, you can write tests using JavaScript to check response size. For example, use pm.response.size() to get the size in bytes and write assertions to fail tests if size is too large.

Result

Automated tests can catch performance issues early by monitoring response size.

Automating response size checks saves time and prevents slow API responses in production.

6

Expert

Surprising Factors Affecting Response Size

🤔Before reading on: Do you think compression always reduces response size? Commit to your answer.

Concept: Explore how compression, headers, and data formats influence response size in unexpected ways.

Response size can be affected by server compression (like gzip), which reduces size but may add CPU load. Also, headers can add unexpected bytes, and different data formats (JSON vs XML) vary in size. Sometimes compression might not help if data is already small or encrypted.

Result

You gain a deeper understanding of what controls response size beyond just data volume.

Knowing these factors helps you optimize APIs and interpret response size correctly.

Under the Hood

When a client sends a request, the server processes it and prepares a response. This response includes headers (metadata like content type, length, encoding) and the body (the actual data). The server may compress the body to reduce size. The total response size is the sum of all bytes sent over the network. Postman measures this by counting all bytes received, including headers and body, after decompression if enabled.

Why designed this way?

Response size measurement includes headers because they consume network bandwidth and affect performance. Compression was introduced to reduce data transfer size and speed up communication, balancing network load and server CPU use. Postman shows response size to give developers a clear picture of data transfer costs, helping optimize APIs for real-world use.

Client Request ──▶ Server
       │               │
       │               ▼
       │         Process Request
       │               │
       │               ▼
       │         Prepare Response
       │               │
       │               ▼
       │◀──────────────┤
       │  Response (Headers + Body)
       │
       ▼
Postman Measures Total Bytes Received

Myth Busters - 4 Common Misconceptions

Quick: Does response size shown in Postman include headers? Commit to yes or no before reading on.

Common Belief: Response size only counts the body data, not headers.

Reality: Response size includes both headers and body data because both consume network bandwidth.

Why it matters: Ignoring headers can underestimate the actual data transferred, leading to wrong performance assumptions.

Quick: Does enabling compression always reduce response size? Commit to yes or no before reading on.

Common Belief: Compression always makes the response size smaller.

Reality: Compression usually reduces size but can sometimes increase it if data is already compressed or encrypted.

Why it matters: Assuming compression always helps can cause confusion when response size unexpectedly grows.

Quick: Is a smaller response size always better? Commit to yes or no before reading on.

Common Belief: Smaller response size always means better performance and quality.

Reality: Too small a response might miss important data, hurting functionality despite faster speed.

Why it matters: Focusing only on size can lead to incomplete or broken API responses.

Quick: Does response size affect only network speed? Commit to yes or no before reading on.

Common Belief: Response size only impacts how fast data travels over the network.

Reality: Response size also affects memory use, parsing time, and battery life on devices.

Why it matters: Overlooking these effects can cause poor user experience beyond just slow loading.

Expert Zone

1

Response size can vary between environments due to different compression settings or proxy servers adding headers.

2

Measuring response size after decompression differs from raw network size; both are useful but serve different purposes.

3

Some APIs use chunked transfer encoding, which affects how response size is calculated and perceived.

When NOT to use

Response size checks are less useful for streaming APIs or real-time data where size varies constantly. Instead, focus on throughput or latency metrics.

Production Patterns

In production, teams set size limits in automated tests to prevent regressions. They also monitor response size trends over time to catch performance degradation early.

Connections

Network Bandwidth

Response size directly affects bandwidth usage.

Understanding response size helps optimize bandwidth consumption, reducing costs and improving speed.

Performance Testing

Response size is a key metric in performance testing of APIs.

Knowing response size helps testers simulate realistic loads and identify bottlenecks.

Data Compression Algorithms

Compression algorithms influence response size by reducing data volume.

Understanding compression helps interpret response size changes and optimize API responses.

Common Pitfalls

#1 Ignoring headers when measuring response size.

Wrong approach:

const size = pm.response.text().length; // counts only body characters

Correct approach:

const size = pm.response.size(); // counts headers + body in bytes

Root cause:

Misunderstanding that headers also consume data and affect total response size.

#2 Assuming compression always reduces response size.

Wrong approach:

Expecting response size to shrink after enabling gzip without testing.

Correct approach:

Test response size with and without compression to verify actual effect.

Root cause:

Overgeneralizing compression benefits without considering data type or encryption.

#3 Setting response size limits too low, breaking functionality.

Wrong approach:

Failing tests if response size exceeds an unrealistically small threshold.

Correct approach:

Set size limits based on realistic API data needs and user requirements.

Root cause:

Confusing smaller size with better quality, ignoring necessary data volume.

Key Takeaways

Response size measures the total data sent back by the server, including headers and body.

Monitoring response size helps balance API speed and completeness for better user experience.

Postman shows response size clearly, enabling easy performance checks during testing.

Compression and headers affect response size in ways that require careful understanding.

Automated tests for response size prevent slow or bloated API responses in production.

Practice

1. What does pm.response.size().body return in Postman?

easy

A. The total number of headers in the response

B. The HTTP status code of the response

C. The size of the response body in bytes

D. The time taken to receive the response

Solution

1. Step 1: Understand the method pm.response.size()

   This method returns an object containing sizes of different parts of the response.

2. Step 2: Identify what .body accesses

   The .body property specifically returns the size of the response body in bytes.

3. Final Answer:

   The size of the response body in bytes -> Option C

4. Quick Check:

   pm.response.size().body = response body size [OK]

Hint: Remember .body gives size in bytes of response content [OK]

Common Mistakes:

• Confusing response size with status code
• Thinking it returns header count
• Assuming it returns response time

2. Which of the following is the correct syntax to assert that the response body size is less than 5000 bytes in Postman test script?

easy

A. pm.response.size().body < 5000;

B. pm.expect(pm.response.size().body).to.be.below(5000);

C. assert(pm.response.body.size < 5000);

D. pm.response.size.body < 5000;

Solution

1. Step 1: Identify correct assertion syntax in Postman

   Postman uses Chai assertion library with pm.expect() for assertions.

2. Step 2: Check the correct property and method usage

   The correct way to get response body size is pm.response.size().body, and to assert it is below 5000 bytes, use to.be.below(5000).

3. Final Answer:

   pm.expect(pm.response.size().body).to.be.below(5000); -> Option B

4. Quick Check:

   Use pm.expect() with to.be.below() [OK]

Hint: Use pm.expect() with to.be.below() for size assertions [OK]

Common Mistakes:

• Using incorrect property like pm.response.body.size
• Missing pm.expect() wrapper
• Using plain comparison without assertion

3. Given the following Postman test script:
<pre>pm.test('Body size check', () => { const size = pm.response.size().body; pm.expect(size).to.be.above(1000); pm.expect(size).to.be.below(3000); });
What will happen if the response body size is 3500 bytes?

medium

A. The test will fail because 3500 is not below 3000

B. The test will pass because 3500 is above 1000

C. The test will fail because 3500 is not above 1000

D. The test will pass because both conditions are true

Solution

1. Step 1: Analyze the assertions in the test

   There are two assertions: size must be above 1000 and below 3000 bytes.

2. Step 2: Check the given size against assertions

   3500 is above 1000 (true) but not below 3000 (false), so the second assertion fails.

3. Final Answer:

   The test will fail because 3500 is not below 3000 -> Option A

4. Quick Check:

   3500 < 3000? No, test fails [OK]

Hint: Check all assertions; one fail means test fails [OK]

Common Mistakes:

• Ignoring the upper bound assertion
• Assuming test passes if one assertion passes
• Confusing above and below conditions

4. You wrote this Postman test:

pm.test('Check response size', () => {
  pm.expect(pm.response.size.body).to.be.below(2000);
});

But the test always fails with an error. What is the problem?

medium

A. Incorrect property access; should use pm.response.size().body

B. The assertion method to.be.below() is invalid

C. pm.expect() cannot be used inside pm.test()

D. Response size cannot be checked in Postman tests

Solution

1. Step 1: Identify the property access error

   The code uses pm.response.size.body which is incorrect because size is a function, not an object.

2. Step 2: Correct the syntax

   The correct syntax is pm.response.size().body to get the response body size.

3. Final Answer:

   Incorrect property access; should use pm.response.size().body -> Option A

4. Quick Check:

   Use parentheses for size() function [OK]

Hint: Remember size() is a function, not a property [OK]

Common Mistakes:

• Missing parentheses after size()
• Misusing assertion methods
• Thinking pm.expect() is invalid inside pm.test()

5. You want to write a Postman test that fails if the response body size is either too small (less than 100 bytes) or too large (more than 5000 bytes). Which test script correctly implements this?

hard

A. pm.test('Body size limits', () => {
const size = pm.response.size().body;
pm.expect(size).to.be.within(100, 5000);
});

B. pm.test('Body size limits', () => {
const size = pm.response.size().body;
pm.expect(size < 100 || size > 5000).to.be.false;
});

C. pm.test('Body size limits', () => {
const size = pm.response.size().body;
pm.expect(size).to.be.above(100) && pm.expect(size).to.be.below(5000);
});

D. pm.test('Body size limits', () => {
const size = pm.response.size().body;
if(size < 100 || size > 5000) {
throw new Error('Body size out of limits');
}
});

Solution

1. Step 1: Understand the requirement

   The test should fail if size is less than 100 or greater than 5000 bytes.

2. Step 2: Evaluate each option's logic

   pm.test('Body size limits', () => { const size = pm.response.size().body; pm.expect(size).to.be.within(100, 5000); }); uses within(100, 5000) which includes 100 and 5000, but does not fail outside range explicitly.
   pm.test('Body size limits', () => { const size = pm.response.size().body; pm.expect(size < 100 || size > 5000).to.be.false; }); uses a boolean expression inside pm.expect() which is not a valid assertion.
   pm.test('Body size limits', () => { const size = pm.response.size().body; pm.expect(size).to.be.above(100) && pm.expect(size).to.be.below(5000); }); uses two assertions combined with && which does not work as expected in Postman.
   pm.test('Body size limits', () => { const size = pm.response.size().body; if(size < 100 || size > 5000) { throw new Error('Body size out of limits'); } }); throws an error explicitly if size is out of limits, causing the test to fail correctly.

3. Final Answer:

   Option D correctly fails the test when size is out of limits -> Option D

4. Quick Check:

   Throw error to fail test on condition [OK]

Hint: Use throw Error to fail test on size limits [OK]

Common Mistakes:

• Using invalid assertion syntax for range checks
• Combining assertions incorrectly with &&
• Not explicitly failing test on condition