Bird
Raised Fist0
Postmantesting~15 mins

Creating monitors in Postman - Automation Script Walkthrough

Choose your learning style10 modes available
Create a Postman Monitor for API Collection
Preconditions (2)
Step 1: Open Postman application or web version
Step 2: Navigate to the Collections tab
Step 3: Select the desired collection to monitor
Step 4: Click on the three dots (options) next to the collection name
Step 5: Choose 'Monitor' from the dropdown menu
Step 6: Click 'Create a monitor' button
Step 7: Enter a monitor name, e.g., 'Daily API Check'
Step 8: Set the environment if needed
Step 9: Set the schedule to run every day at 9 AM
Step 10: Click 'Create Monitor' to save
✅ Expected Result: A new monitor is created for the selected collection, scheduled to run daily at 9 AM, and visible under the Monitors tab
Automation Requirements - Postman API with Newman and Node.js
Assertions Needed:
Verify the monitor creation API returns status 201
Verify the monitor name matches the input
Verify the schedule is set correctly
Verify the monitor is listed when fetching monitors
Best Practices:
Use environment variables for collection and environment IDs
Use explicit API calls to create and verify monitors
Handle API authentication securely with Postman API key
Use async/await for API calls
Validate responses with proper assertions
Automated Solution
Postman
import fetch from 'node-fetch';

const POSTMAN_API_KEY = process.env.POSTMAN_API_KEY;
const COLLECTION_UID = process.env.COLLECTION_UID; // e.g. '123abc'
const ENVIRONMENT_UID = process.env.ENVIRONMENT_UID; // optional

async function createMonitor() {
  const url = 'https://api.getpostman.com/monitors';

  const monitorData = {
    monitor: {
      name: 'Daily API Check',
      collection: {
        uid: COLLECTION_UID
      },
      environment: ENVIRONMENT_UID ? { uid: ENVIRONMENT_UID } : undefined,
      schedule: {
        type: 'daily',
        interval: 1,
        time: '09:00'
      }
    }
  };

  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'X-Api-Key': POSTMAN_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(monitorData)
  });

  if (response.status !== 201) {
    throw new Error(`Failed to create monitor, status code: ${response.status}`);
  }

  const data = await response.json();

  if (data.monitor.name !== 'Daily API Check') {
    throw new Error('Monitor name does not match');
  }

  if (!data.monitor.schedule || data.monitor.schedule.type !== 'daily' || data.monitor.schedule.time !== '09:00') {
    throw new Error('Monitor schedule is incorrect');
  }

  console.log('Monitor created successfully:', data.monitor.uid);

  // Verify monitor is listed
  const listResponse = await fetch(url, {
    method: 'GET',
    headers: {
      'X-Api-Key': POSTMAN_API_KEY
    }
  });

  if (listResponse.status !== 200) {
    throw new Error(`Failed to fetch monitors, status code: ${listResponse.status}`);
  }

  const listData = await listResponse.json();
  const found = listData.monitors.some(m => m.uid === data.monitor.uid);

  if (!found) {
    throw new Error('Created monitor not found in monitor list');
  }

  console.log('Monitor verified in list successfully');
}

createMonitor().catch(err => {
  console.error('Test failed:', err.message);
  process.exit(1);
});

This script uses Node.js with the node-fetch library to call the Postman API.

First, it reads environment variables for the API key, collection UID, and optionally environment UID.

It sends a POST request to create a monitor with the specified name, collection, and schedule.

It checks the response status is 201 (created) and verifies the monitor name and schedule in the response.

Then it sends a GET request to list all monitors and confirms the newly created monitor is present.

Errors are thrown if any assertion fails, causing the script to exit with failure.

This approach uses async/await for clear asynchronous code and environment variables for sensitive data.

Common Mistakes - 4 Pitfalls
Hardcoding API keys directly in the script
Not checking HTTP response status codes before parsing JSON
Ignoring asynchronous nature and not using async/await or proper promise handling
Not verifying that the created monitor appears in the monitor list
Bonus Challenge

Now add data-driven testing to create monitors with 3 different schedules: daily at 9 AM, weekly on Monday at 10 AM, and hourly every 2 hours.

Show Hint

Practice

(1/5)
1. What is the main purpose of creating a monitor in Postman?
easy
A. To run API tests automatically on a schedule
B. To manually execute API requests one by one
C. To write new API test scripts
D. To create API documentation

Solution

  1. Step 1: Understand what monitors do

    Monitors in Postman are designed to run tests automatically without manual intervention.
  2. Step 2: Identify the main use

    They run API tests on a schedule to catch issues early.
  3. Final Answer:

    To run API tests automatically on a schedule -> Option A
  4. Quick Check:

    Monitors = Automated scheduled tests [OK]
Hint: Monitors run tests automatically, not manually [OK]
Common Mistakes:
  • Thinking monitors are for manual testing
  • Confusing monitors with writing test scripts
  • Assuming monitors create documentation
2. Which of the following is required before creating a monitor in Postman?
easy
A. A manual test run report
B. An active Postman environment variable
C. A Postman workspace with no collections
D. A saved collection with tests

Solution

  1. Step 1: Recall monitor prerequisites

    Monitors need a saved collection that contains tests to run automatically.
  2. Step 2: Check other options

    Environment variables help but are not strictly required; a workspace without collections cannot run tests; manual reports are unrelated.
  3. Final Answer:

    A saved collection with tests -> Option D
  4. Quick Check:

    Monitor setup = saved collection needed [OK]
Hint: Monitors need collections with tests saved first [OK]
Common Mistakes:
  • Assuming environment variables are mandatory
  • Trying to create monitors without collections
  • Confusing manual reports with monitor setup
3. Consider this scenario: You create a monitor for a collection that tests an API endpoint. The monitor is set to run every hour. What will happen if the API is down during a monitor run?
medium
A. The monitor will skip the test and report success
B. The monitor run will fail and report errors
C. The monitor will run tests but ignore failures
D. The monitor will automatically fix the API issue

Solution

  1. Step 1: Understand monitor behavior on failure

    If the API is down, the requests in the collection will fail during the monitor run.
  2. Step 2: Identify monitor reporting

    Monitors report test failures and errors; they do not skip or ignore failures, nor fix issues automatically.
  3. Final Answer:

    The monitor run will fail and report errors -> Option B
  4. Quick Check:

    API down = monitor reports failure [OK]
Hint: Monitors report errors if API is down during run [OK]
Common Mistakes:
  • Thinking monitors skip failed tests
  • Believing monitors fix API problems
  • Assuming monitor reports success despite failures
4. You created a monitor but it never runs at the scheduled time. What is the most likely reason?
medium
A. The collection used by the monitor was deleted
B. The monitor schedule is set to run every minute
C. The monitor has no tests in the collection
D. The monitor is set to manual run only

Solution

  1. Step 1: Check monitor prerequisites

    If the collection linked to the monitor is deleted, the monitor cannot run.
  2. Step 2: Evaluate other options

    Running every minute is valid; having no tests means no failures but monitor still runs; monitors do not have manual-only mode.
  3. Final Answer:

    The collection used by the monitor was deleted -> Option A
  4. Quick Check:

    Deleted collection = monitor won't run [OK]
Hint: Deleted collection breaks monitor runs [OK]
Common Mistakes:
  • Assuming schedule frequency stops runs
  • Thinking monitors can be manual-only
  • Confusing empty tests with no runs
5. You want to create a monitor that runs your API tests every day at 9 AM UTC and sends email alerts only if tests fail. Which steps should you follow?
hard
A. Create a new collection without tests, schedule monitor hourly, disable alerts
B. Save a collection with tests, create a monitor with no schedule, enable all alerts
C. Save a collection with tests, create a monitor scheduled daily at 9 AM UTC, enable email alerts on failure
D. Create a monitor without a collection, schedule daily, enable email alerts

Solution

  1. Step 1: Prepare the collection

    You must have a saved collection that contains the API tests to run.
  2. Step 2: Configure the monitor schedule and alerts

    Create a monitor scheduled daily at 9 AM UTC and enable email alerts only on test failures.
  3. Final Answer:

    Save a collection with tests, create a monitor scheduled daily at 9 AM UTC, enable email alerts on failure -> Option C
  4. Quick Check:

    Collection + daily schedule + alerts on failure = correct setup [OK]
Hint: Schedule monitor + enable alerts only on failure [OK]
Common Mistakes:
  • Scheduling monitor without tests in collection
  • Disabling alerts when failures occur
  • Creating monitor without a collection
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard