Postman: The Complete Guide - REST API Testing

Set and store the API base URL as a collection variable in Postman to avoid editing many requests when the address changes, and understand variable resolution and scope.

Modify collection variables by editing the variables tab, updating local values, and managing shared values for base URL and password, enabling sharing when needed, and applying changes across multiple requests.

Learn to view API responses in Postman using pretty, raw, and collapse to read JSON with color syntax and collapsible sections; compare raw versus pretty and preview HTML examples.

Explore filtering products by category with query parameters in the api. See how using dairy retrieves dairy items and how 200 and 400 responses reflect input validity; Postman manages parameters.

Learn how API parameters and query parameters work in Postman, focusing on the get products endpoint; only supported parameters affect results, per the API documentation.

Study the API documentation, add the results query parameter to your request, and disable a category to test effect. Try values, observe behavior, and identify bugs ahead of the quiz.

Investigate how the query parameter results control the number of products returned, default 20, with category filtering and invalid values; discuss pagination limitations with the development team.

Learn to speed up Postman workflows by using keyboard shortcuts. Enable shortcuts in settings, explore basics like new tab, save the request, and navigate tabs across macOS and Windows.

Learn how path variables work in rest apis by using the endpoint /products/{productId} to fetch a single product in Postman, and distinguish path parameters from query parameters.

Troubleshoot path variables in Postman by inspecting the console, replace placeholders with valid values, and verify the URL and resolved variables to avoid 400 bad request errors.

Identify path variables and query parameters. Follow api documentation to know which are mandatory or optional, and remember path variables come before the question mark; query parameters come after.

Learn how business processes and rules shape API testing with a grocery store example, from searching products and creating a cart to placing orders and enforcing authentication constraints.

Perform a post request in Postman to create a new cart, understand authorization requirements and cart IDs, and compare post with get for REST API testing.

Study the api documentation to use the get cart and get cart items endpoints in Postman. Verify the cart returns status 200 and an empty items list.

Explore how JSON transfers data between systems, structure data with keys and values, and use post requests to add items to a cart for API testing.

Demonstrate posting a JSON body to add a cart item, using the card id in the path and product id in the body, and observe 400 and 201 responses.

Learn how to troubleshoot post requests by validating base url, cart id, and json payload, choosing the correct post method, and following the API documentation for single-item adds.

Contrast get and post methods: get retrieves data with no side effects, while post creates data using a request body; consult API docs to choose the correct endpoint.

Learn how to authenticate with APIs using Postman by registering an API client, obtaining an access token, and applying a bearer token in request headers and collection variables.

Master troubleshooting status codes in Postman by validating endpoints, request methods, and json payloads, and reading error messages to align with api documentation.

Practice placing an order by building and testing the request, guided by a step-by-step quiz. Study the API documentation and experiment with the API before viewing the solution.

Use Postman's random full name variable to generate a different customer name for each API request, enabling testing with varied data sets and revealing API edge cases.

Postman automatically manages HTTP headers, including content-type as application/json; learn to view and override headers like authorization by redefining them, and understand duplicate and inherit auth behavior.

Explore why http headers matter and how to use authorization and content-type headers effectively in rest api testing, with guidance from Postman defaults and api documentation.

Explore how headers, query parameters, and path variables form the address in HTTP requests, and how Postman visualizes them as key-value panels, two distinct concepts within the HTTP message.

Learn how to export and import a Postman collection, generate access keys, share links securely, import from cloud or file, and understand initial vs current values and token privacy.

Apply a patch request to update an order by its order ID with bearer authorization, then fetch all orders to confirm the customer name is Joe Doe.

Learn how to perform a patch request in Postman to update only the comment on an order, leaving the customer name unchanged, with a 204 no content response.

Define a cart id variable in Postman and reference it in get cart, get cart items, and add item requests to avoid duplication across all requests.

Demonstrate updating a cart item quantity with a patch request using cart ID and item ID, sending a quantity in the body, and observing a 204 no content response.

Use a put request to replace a cart item by supplying cartId and itemId in the path and a new productId in the body, updating the entire item.

Learn how to delete an item from a cart using the HTTP delete method in Postman, including sending no body and handling a 204 no content response.

Practice deleting resources by removing an existing order to reinforce delete operations in rest api testing with Postman.

Learn to choose the right http method by studying API documentation; use get to fetch data, post to create, put to replace, patch for partial updates, and delete to remove.

Explore the head request method, a lightweight http request that returns a 200 without a body. Use it to verify that an api endpoint is up without transferring data.

Practice building and testing APIs with Postman by guiding Trello boards, lists, and tasks through hands-on steps, embracing mistakes to master REST API testing.

Learn to work with real-world APIs by using Trello's API through Postman, creating boards, lists, and tasks, and comparing UI actions with underlying API calls.

Learn to navigate public API documentation, identify resources like boards, and perform a simple POST to create a board at api.trello.com/1/boards using a key and token.

Discover how to configure a Trello power-up to generate an API key and token, then test Trello API calls in Postman using proper credentials and collections.

Follow the api documentation to authenticate via key and token as query params, avoid spaces, save requests in a collection, and use proper post requests to create boards.

Identify resources by their unique id rather than name, and master path versus query parameters to retrieve a single board or list of boards in the Trello API with Postman.

Create a to-do and a done list on the learning postman board using the trello api, and archive default lists to simulate their absence.

Learn to create a new list on a board with a POST request to the lists endpoint, supplying name and idBoard, and validating the returned list ID.

Learn to create a new card via the cards endpoint with a POST request, provide the card name and required ID list, and see how lists and boards relate.

Explore how to move a Trello card through the REST API by treating it as a resource, performing create, delete, or update operations, and verify the result on Trello.com.

Move a card from the to-do list to the done list by updating the id list with a put request, using path and query parameters.

Delete a board to clean up your Postman workspace, then verify the deletion with a get request that returns 200 and a sim request to confirm removal.

Learn to delete a board in Postman using delete with a board id, verify with a 404 for the deleted board, and save the request for cleanup.

Protect your api keys by revoking exposed credentials, using postman variables for secrets, securing workspaces, and avoiding posting keys in public course q&a.

Learn JavaScript basics to unlock Postman for API tests and advanced testing, and avoid confusing JavaScript with Java.

Learn how to write Postman scripts, using pre-request scripts to run code before a request and post-response scripts to run after, including console logging and clearing.

Define JavaScript variables in Postman scripts with var, label them like FirstName and Age, and use console.log to verify values while noting variables are temporary and not stored by Postman.

Use let instead of var to define variables in modern JavaScript and avoid reliability issues. Understand undefined when a value isn't set, and how quotes distinguish strings from numbers.

Master JavaScript variable naming by using camelCase and snake_case, choosing descriptive names, preferring is/has prefixes for booleans, avoiding abbreviations, and respecting case sensitivity for readable code.

Define constants with const to keep values unchanged during code execution, such as a website url or the seconds in a day, and switch to let if reassignment is needed.

Master JavaScript arithmetic with addition, subtraction, multiplication, and division, including increment and decrement and variable usage. Learn to convert strings to numbers with parseInt and parseFloat, and recognize NaN.

Explore how code blocks create block scope in JavaScript, how global scope interacts, and how let inside blocks prevents naming collisions.

Explore how JavaScript functions work, from defining named functions and calling them with parentheses to using parameters and arguments, and understand function scope and reuse.

Learn how to define a function add with parameters a and b, call it with arguments, and use return to produce the sum, using console.log and backticks for template strings.

Explore built-in JavaScript functions, generate random numbers with Math.random, and convert to integers with Math.floor. Create reusable getRandomNumber functions using a maxValue parameter.

Explore storing functions in variables, anonymous functions, and arrow function shortcuts in JavaScript, including parameter handling, one-line expressions, and automatic return.

Master callback functions by passing a function as an argument and calling it later after an event. Apply asynchronous, event-driven execution with setTimeout in JavaScript and Postman API testing.

Explore callback functions in Postman by building tests with pm.test, using a name and an anonymous or arrow function, and asserting status with pm.response.to.have.status.

Explore how to define and use objects in JavaScript, including properties, dot notation, and methods, plus how to add properties later and why capitalization affects access.

Objects gain behavior through methods, which are functions attached to the object. Call a method with parentheses to execute it, as sayHello returns value when invoked on the person object.

Learn how to reference an object's properties in its methods using this. Compare classical functions with arrow functions and avoid external dependencies for reliable object behavior.

Apply square bracket notation instead of dot notation with quoted property names like 'first-name' or 'e-mail' to access or set object properties that include spaces or dashes.

Learn how JavaScript objects are serialized to JSON with JSON.stringify and restored with JSON.parse, and why JSON represents data, not functions, for API transfers.

Write and validate Postman tests using pm.test and pm.expect to assert response.status equals up. Learn to print data to the console, handle missing properties, and read test results.

Learn how arrays store lists of numbers, strings, and objects in JavaScript, and how to manage dynamic collections of people, hobbies, and other data with arrays and nested arrays.

Learn to access items in arrays and nested objects using zero-based indices, square bracket notation, and dot notation, including the TikTok handle in socialProfiles.

Navigate complex postman responses by parsing json in tests and tracing nested objects and arrays to reach active properties. Use the postman console to inspect and verify data.

Explore array manipulation in postman: use push to add items, length to count, index-based access, and pop or shift to remove elements.

Master essential JavaScript concepts and boost confidence in writing code as you practice with Postman, review coding exercises, and prepare for more advanced JavaScript in the course.

verify each api endpoint returns expected status code as part of functional testing. document and test with postman snippets to ensure status 200 for the status endpoint and notice changes.

Learn to write status code tests for every request in a Postman collection and ensure tests fail when needed, guided by a step-by-step quiz.

Demonstrates adding status code tests for all collection requests, updates assertions from 200 to 201 as needed, and uses collection variables to validate cart, item, and order endpoints.

Learn to assert the API response body in Postman tests by validating product name, price, and stock, beyond status 200, using hard-coded IDs and stock checks.

Learn to write resilient REST API tests in Postman by asserting data types, such as price as a number above zero and response as an object.

Test api error handling by combining happy path and negative scenarios in Postman, including missing authentication, invalid tokens, and 401 errors, while organizing requests with folders for clarity.

Organize authentication tests by duplicating requests to cover missing header and invalid token scenarios. Reuse tests at folder level to apply status checks across requests, reducing duplication and simplifying maintenance.

Identify and reduce duplication in Postman requests and tests by organizing names with use-case hints, such as missing header or invalid token, guided step by step through this assignment.

organize Postman rest api tests to reduce duplication by moving tests into folder levels, creating missing header and invalid token folders, and enabling folder-level tests for easier maintenance.

Explore boundary testing by identifying invalid values for the results query parameter while considering the category parameter in a hands-on Postman REST API testing assignment.

Demonstrates boundary testing for a REST API endpoint by validating the maximum value of 20 for the results parameter, ensuring 400 bad request responses and exact error messages in tests.

Document requests, folders, and collections in Postman by adding detailed descriptions and notes to each request, folder, and the collection to clarify purpose, tests, and expected outcomes.

Learn to automate API testing by setting and reading Postman variables in scripts, eliminating manual data changes and streamlining requests for robust automation.

Master setting Postman collection variables from scripts with the set method, creating or updating variables by key and value. Learn to reference JavaScript variables for dynamic data in your requests.

Learn to chain requests in postman by extracting an in-stock product ID from the get all products response, storing it in a collection variable, and using it in subsequent requests.

Apply the fail-fast principle in Postman testing to validate collection variables by guarding against undefined responses, asserting a non-empty array, and verifying product.id and inStock before setting variables.

Set up a Postman assignment to capture cartId from the response body and store it as a collection variable for use in all subsequent requests, guided by a step-by-step quiz.

Store dynamic API data in Postman variables by scripting the item ID from responses and reusing it across requests, and apply same to the order ID with tests for robustness.

Explore how to store dynamic data in Postman variables, creating carts, items, and orders, and reuse itemId and orderId across requests with collection variables and tests.

Learn how to set and retrieve postman collection variables in scripts using pm.collectionVariables.get and set, and validate them in tests with console.log.

Practice using Postman variables in scripts by writing a test that verifies the response body contains the order ID from a get single order request after deletion.

Master JavaScript data type comparisons with the greater than operator and strict equality using triple equals, understand loose equality, and avoid assignment mistakes in expressions.

Use a JavaScript for loop to search the orders array in Postman, with initialization, a condition, and afterthought, and log results with console.log.

Write a for loop to iterate over a JavaScript array, access each item by index, and print values with console.log using array.length for dynamic sizes.

Master JavaScript conditionals with if statements by evaluating age and displaying messages like 'You are an adult' using age >= 18, else blocks, and proper semicolon usage.

Parse get all orders response, iterate over the order array with a for loop, and compare each id to the last submitted orderId from collection variables to verify a match.

Write assertions against an order id in a response array by wrapping code in pm.test, then track a boolean and assert it with pm.expect(...).to.be.true.

Learn how to iterate over arrays with the built-in forEach method, using a callback with item and index, including anonymous and arrow function forms, and replacing loops with forEach.

Discover how the javascript find method locates an array element using a callback. Write conditions to search objects by name or email and manage not-found cases.

Replace the four forEach calls in the get all orders test with the array find method to practice hands-on testing.

Learn to replace forEach with find to locate an order by id in a response array, assert the result is an object, and simplify Postman tests.

Learn how Postman variables preserve data types when set from scripts and edits can convert numbers to strings. Centralize changes and use typeof with collectionVariables.set/get to maintain type.

Master passing data from pre-request scripts to requests and tests in Postman by creating dynamic variables, such as random quantity values, and using them in the API call.

learn to use postman variables across the request builder and scripts, including in url, query params, path variables, authorization headers, body, and tests, using pm.collectionVariables.get.

Learn how to manage and remove collection variables in Postman, using set and unset for single variables, and avoid the destructive clear that wipes all variables from the current scope.

Use test-driven development (TDD) to write tests before code, shaping the interface and documenting requirements. The lecture shows applying API testing with negative inputs and automated tests guiding bug fixes.

Learn to use Postman environments and environment variables to test across multiple servers, switching the base URL between testing and production while understanding precedence with collection variables.

Learn how to use if statements in Postman scripts to run tests only on the testing environment, using pm.environment.name to differentiate environments and guard tests.

Environments keep production data separate from testing and require environment-specific tokens. Store the accessToken as an environment variable and use the secret option to hide it.

Export and import Postman environments as files, learn that initial values are shared but current values and secrets are not, and add secrets after importing.

Learn how to manage Postman environment variables from scripts using pm.environment.set, pm.environment.get, and pm.environment.unset, and understand the importance of selecting an environment.

Discover how to fetch variables by current scope in Postman scripts with pm.variables.get, automatically resolving collection or environment values and matching the request builder's curly braces syntax.

Migrate collection variables to environment variables by moving baseUrl, accessToken, cartid, lastAddedItemid, and orderid into production and testing environments, and replace pm.collectionVariables.set and pm.collectionVariables.get with pm.environment.set and pm.variables.get.

Learn to set, get, and remove Postman global variables in scripts using pm.globals.set, pm.globals.get, and pm.globals.unset, with scope-aware retrieval via pm.variables.get for firstName Jamie.

Practice what you have learned by applying Postman skills to the Trello API, creating tasks that document functionality, using variables to streamline requests, and writing scripts to handle complex scenarios.

Write status code tests for every request in the Trello API collection, ensuring no environment is selected to avoid base URL overrides, and follow a step-by-step quiz.

Write and run status code tests in postman to validate 200 ok responses for boards, to-do lists, and cards, and 404 for deleted resources, documenting collection behavior.

Use Postman variables across requests to pass data from one request to the next. Execute them top to bottom without copy-paste, guided by the assignment and its step-by-step quiz.

Learn how to use Postman collection variables to store and reuse ids like boardId, todoListId, doneListId, and cardId when testing the Trello API, enabling end-to-end requests with automated checks.

Automate board cleanup by retrieving the first board ID with the get all boards request, storing it in a postman variable named board ID, and executing the delete board request.

Automate counting and deleting Trello boards in Postman by scripting pm.response.json, using array length, and updating a collection variable boardId to remove boards without manual copy-paste.

Learn how the JavaScript map method transforms each array element with a callback, producing a new array while leaving the original intact, including examples that extract emails from objects.

Learn to store an array of board ids from a get all boards response into a Postman collection variable, use map and pre-request scripts to delete boards one by one.

Write tests for the create board request to verify creation, check status code, and validate the response body: board name, open state, prefs permission level private, and calendar view disabled.

Demonstrates writing Postman tests to verify created board properties, including name and private status, and uses console logs and find to access the calendar view and assert calendar.enabled is false.

Implement dynamic board names in Postman by using a unique naming convention with a leading # and incremental numbers (1–10) after each request, guided by a step-by-step quiz.

Delete all boards, then create dynamic boards named Learning Postman 1, 2, 3 using a pre-request script that increments a collection variable and handles isNaN initialization.

Write tests for creating todo and done lists, verify response names, ensure lists are open, and confirm the board reference ID matches the Postman collection variable.

Test the put request to move a card from the to-do list to the done list, and verify the card's name remains as provided when created.

Move the card to the done list and validate the response as JSON, verify the card name remains the same, and confirm the tests pass.

Learn to write resilient Postman tests that gracefully handle non-json responses, isolate parsing errors, and keep test suites running by encapsulating failures within individual tests.

Learn to write postman assertions with the chai library, including eql vs equal, not, includes, one of, and regex checks, using pm.expect across arrays, objects, and strings.

Run the collection manually to verify each request and its tests before automating, using variables to avoid data copy and ensure API endpoints work as expected.

Examine how Postman uses local variables in a collection and how to share critical values—base URL, key, and token—with external automation tools via the shared value feature.

Understand collection runner usage limits on the free and paid Postman plans. The free plan restricts to 25 runs per month, with soft and hard limits that can block usage.

Schedule collection runs in Postman to run on the cloud and monitor results for publicly accessible APIs. Persist all variable values to ensure tokens are available to scheduled runs.

Run Postman collections in a ci/cd pipeline to automatically build, test, and deploy APIs with no human intervention using Newman or Postman CLI on ci servers.

Install and use the Postman CLI to run a Trello API collection, log in with an API key, execute the run, and review detailed reports for iterations, requests, and debugging.

Install Node.js LTS, install Newman via npm, and run a Postman collection using its API URL and access key, then read the execution report with assertions and request details.