GET request in Postman - Deep Dive

Overview - GET request

What is it?

A GET request is a way to ask a server for information. It is one of the most common methods used on the internet to retrieve data from websites or APIs. When you send a GET request, you are simply asking to get some data without changing anything on the server. It is like looking up information in a book without writing or changing anything inside it.

Why it matters

GET requests exist because they allow users and programs to fetch data quickly and safely without altering the server's content. Without GET requests, we would not be able to browse websites, check weather updates, or retrieve any online information easily. The world without GET requests would be like a library where you cannot read any books, only write in them, which would be confusing and unsafe.

Where it fits

Before learning about GET requests, you should understand basic internet concepts like servers, clients, and URLs. After mastering GET requests, you can learn about other HTTP methods like POST, PUT, and DELETE, which allow you to send or change data on servers.

Mental Model

Core Idea

A GET request is like asking a librarian for a specific book page without changing anything in the library.

Think of it like...

Imagine you go to a library and ask the librarian to show you a particular page from a book. You only want to read it, not write or erase anything. The librarian finds the page and shows it to you. This is exactly how a GET request works: you ask a server for some data, and it gives it to you without changing anything.

┌─────────────┐       GET Request       ┌─────────────┐
│   Client    │ ──────────────────────▶ │   Server    │
└─────────────┘                        └─────────────┘
       ▲                                      │
       │                                      │
       │           Response with Data         │
       └──────────────────────────────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding HTTP and URLs

Concept: Learn what HTTP is and how URLs identify resources.

HTTP stands for HyperText Transfer Protocol. It is the language used by browsers and servers to communicate. A URL (Uniform Resource Locator) is the address of a resource on the internet, like a webpage or data. For example, https://example.com/data points to a resource named 'data' on the server 'example.com'.

Result

You know that HTTP is the communication method and URLs tell where to find data.

Understanding HTTP and URLs is essential because GET requests use these to ask for specific data from servers.

2

Foundation

Basics of GET Request Method

Concept: GET is an HTTP method used to request data from a server.

When you type a website address in your browser or click a link, your browser sends a GET request to the server. The server then sends back the requested webpage or data. GET requests do not change anything on the server; they only retrieve data.

Result

You see that GET requests are safe ways to get information without side effects.

Knowing that GET requests only retrieve data helps you understand why they are used for reading information.

3

Intermediate

Using GET Requests in Postman

🤔Before reading on: do you think GET requests in Postman can send data in the body? Commit to your answer.

Concept: Learn how to create and send GET requests using Postman, a popular API testing tool.

In Postman, you select GET as the method, enter the URL of the API endpoint, and click 'Send'. You can add query parameters in the URL to specify what data you want. For example, https://api.example.com/users?id=5 asks for user with ID 5. GET requests do not have a body in Postman.

Result

Postman sends the GET request and shows the server's response, including status code and data.

Understanding how to use Postman for GET requests lets you test APIs easily and see how servers respond.

4

Intermediate

Query Parameters in GET Requests

🤔Before reading on: do you think query parameters change the data on the server or just filter what you get? Commit to your answer.

Concept: Query parameters are extra information added to the URL to specify or filter the data you want.

Query parameters come after a question mark (?) in the URL and are key-value pairs separated by ampersands (&). For example, https://api.example.com/products?category=books&sort=price asks for products in the 'books' category sorted by price. These parameters help the server know exactly what data to send back.

Result

You get filtered or specific data based on the query parameters you include.

Knowing how query parameters work helps you request precise data without changing the server.

5

Advanced

Understanding HTTP Status Codes in GET

🤔Before reading on: do you think a successful GET request always returns status code 200? Commit to your answer.

Concept: HTTP status codes tell you if your GET request succeeded or if there was a problem.

When you send a GET request, the server responds with a status code. 200 means success and data is returned. 404 means the resource was not found. 401 means you need to log in. 500 means the server has an error. Understanding these codes helps you know what happened with your request.

Result

You can interpret server responses correctly and handle errors in your tests.

Recognizing status codes is crucial for debugging and validating API behavior.

6

Expert

Caching and Idempotency in GET Requests

🤔Before reading on: do you think GET requests can safely be repeated without side effects? Commit to your answer.

Concept: GET requests are designed to be idempotent and cacheable, meaning they can be repeated safely and their responses can be stored to improve performance.

Idempotent means making the same GET request multiple times has the same effect as making it once. Caching means browsers or servers can save the response and reuse it to avoid repeated work. This improves speed and reduces server load. However, improper caching can cause outdated data to be shown.

Result

You understand why GET requests are safe for repeated use and how caching affects data freshness.

Knowing idempotency and caching helps you design efficient and reliable API tests and applications.

Under the Hood

When a GET request is sent, the client opens a connection to the server and sends an HTTP message with the GET method and the resource URL. The server processes this request by locating the resource, then sends back an HTTP response with a status code and the requested data in the body. The connection may then close or stay open for further requests. The server does not change any data during this process.

Why designed this way?

GET was designed to be a safe and simple way to retrieve data without side effects. Early web design needed a method that browsers could use to fetch pages repeatedly without risk of changing content. Alternatives like POST were reserved for actions that modify data. This separation helps maintain web stability and security.

Client ──GET Request──▶ Server
  │                      │
  │                      ▼
  │                Locate Resource
  │                      │
  │                      ▼
  ◀─HTTP Response with Data─
  │                      │
  Connection stays open or closes

Myth Busters - 4 Common Misconceptions

Quick: Can GET requests send data in the request body? Commit to yes or no.

Common Belief: GET requests can include data in the request body just like POST requests.

Reality: GET requests do not have a request body; any data must be sent via the URL as query parameters.

Why it matters: Trying to send data in the body of a GET request can cause servers to ignore it or behave unexpectedly, leading to failed tests or bugs.

Quick: Does a 200 status code always mean the data you want was found? Commit to yes or no.

Common Belief: A 200 status code means the requested data exists and is returned.

Reality: A 200 status code means the request succeeded, but the data might be empty or not what you expected; for example, an empty list or default page.

Why it matters: Assuming 200 means correct data can cause false positives in tests and misunderstandings about API behavior.

Quick: Are GET requests unsafe because they expose data in the URL? Commit to yes or no.

Common Belief: GET requests are unsafe because sensitive data is visible in the URL.

Reality: GET requests expose data in URLs, so they should not be used for sensitive information like passwords; instead, POST or other secure methods should be used.

Why it matters: Misusing GET for sensitive data can lead to security risks like data leaks in browser history or logs.

Quick: Can GET requests change data on the server? Commit to yes or no.

Common Belief: GET requests can change data if the server is programmed that way.

Reality: By HTTP standards, GET requests should never change server data; if they do, it breaks web principles and can cause unexpected side effects.

Why it matters: Relying on GET to change data can cause bugs, security issues, and unreliable applications.

Expert Zone

1

Some APIs misuse GET requests to perform actions that change data, which violates HTTP standards and can cause caching issues.

2

Caching headers like ETag and Cache-Control control how GET responses are stored and reused, affecting performance and data freshness.

3

GET requests can include complex query parameters, but URL length limits in browsers and servers can restrict how much data you can send.

When NOT to use

Do not use GET requests when you need to send sensitive data, large amounts of data, or when the request changes server state. Instead, use POST, PUT, or PATCH methods which support request bodies and are designed for such purposes.

Production Patterns

In production, GET requests are used for fetching resources like user profiles, product lists, or search results. They are combined with caching strategies to improve performance. Developers also use GET requests with authentication tokens in headers to securely access protected data.

Connections

POST request

complementary HTTP method

Understanding GET helps clarify when to use POST, which sends data to change server state, while GET only retrieves data.

Caching mechanisms

builds-on

Knowing how GET requests work is essential to grasp caching strategies that improve web performance by storing GET responses.

Library book borrowing system

similar process in a different domain

The way GET requests retrieve data without changing it is like borrowing a book to read without altering its content, showing how concepts of safe access appear in many fields.

Common Pitfalls

#1 Trying to send data in the body of a GET request.

Wrong approach:

GET https://api.example.com/users
{
"name": "Alice"
}

Correct approach:

GET https://api.example.com/users?name=Alice

Root cause:

Misunderstanding that GET requests do not support a request body and that data must be sent via URL parameters.

#2 Assuming a 200 status code means the data exists.

Wrong approach:

If response.status == 200 then print('Data found')

Correct approach:

If response.status == 200 and response.body is not empty then print('Data found')

Root cause:

Confusing HTTP success status with actual presence or correctness of data.

#3 Using GET requests to send sensitive information like passwords.

Wrong approach:

GET https://example.com/login?password=12345

Correct approach:

POST https://example.com/login with body {"password": "12345"}

Root cause:

Not recognizing that URLs are visible in browser history and logs, exposing sensitive data.

Key Takeaways

GET requests are used to safely retrieve data from servers without changing anything.

Data in GET requests is sent via the URL using query parameters, not in the request body.

HTTP status codes in GET responses help you understand if the request succeeded or failed.

GET requests are idempotent and cacheable, making them efficient for repeated data fetching.

Misusing GET requests for sensitive data or actions that change server state can cause security and functionality problems.