How to Write Global Functions in Postman

I need help writing a common function to use across a collection of requests which will help with building a framework.

I have tried using the below format

The following function is declared in the Test tab in the first function

postman.setGlobalVariable("function", function function1(parameters)
  //sample code

I used the following in the pre-request

var delay = eval(globals.function);

I am getting the following error

there was error while evaluating the Pre-request script : Cannot read property 'function1' of undefined.

Can anyone help me with how to define Global/common functions and use them across the requests?

Thanks in advance



I use this little hack:

pm.globals.set('loadUtils', function loadUtils() {
    let utils = {};
    utils.reuseableFunction = function reuseableFunction() {
        let jsonData = JSON.parse(responseBody);
    return utils;
} + '; loadUtils();');
tests['Utils initialized'] = true;

In another request I can reuse the global variable loadUtils:

const utils = eval(globals.loadUtils);

You can also check the developer roadmap of the Postman team. Collection-level scripts are on the near-term agenda and should be available soon until then you can use the shown method.


You can have a more readable solution and more possibility to factor your code (like calling function1() from function2() directly inside your pre-request script, or declaring packages) with the following syntax :

Initialize environment (or globals) :

postman.setEnvironmentVariable("utils", () => {
    var myFunction1 = () => {
        //do something
    var myFunction2 = () => {
        let func1Result = myFunction1();
        //do something else
    return {
        myPackage: {

And then use your functions in a later test :

let utils = eval(environment.utils)();
utils.myPackage.myFunction1(); //calls myFunction1()
utils.myPackage.myFunction2(); //calls myFunction2() which uses myFunction1()

Bonus :

If you are calling an API and need to wait the call to finish before performing a test, you can do something like this:

postman.setEnvironmentVariable("utils", () => {
    var myFunction = (callback) => {
        return pm.sendRequest({
            // call your API with postman here
        }, function (err, res) {
            if (callback) {
                //if a callback method has been given, it's called

    return {
        myPackage: {

and then to use it:

utils.myPackage.myFunction(function() {
    console.log("this is the callback !")
    //perform test here

If you want to call pm.sendRequest in a global function, try this:

  1. Define the global function in collection pre-request, like this:

    pm.globals.set('globalFunction', parameters => {
        pm.sendRequest('', function(err, resp) {
  2. Use function like this:

    eval(globals.globalFunction)('hello world!!');

Note that, I declared function using arrow style ()=>{}. Otherwise, it wouldn't work.


You can declare a global function by assigning this function into a collection, environment or global variable as follows:

  • Create a collection variable, i.e. global_func
  • In the variable value write this code,

(number)=> { return number * number }

to reuse this function elsewhere in your collection

let numberSquared = eval(pm.variables.get('global_func'))(5)

now, numberSqaure variables has a value of 25


if you need to declare a function library: you can create a collection variable and assign it this piece of code:

    print:function() {
        console.log('hello Postman')
    squared:function(number) {
        return number * number

Note: the functions have been enclosed with parentheses

to reuse this library:

let lib = eval(pm.variables.get('global_func'))

Good luck :)


The problem had perplexed me for a while until I found the common way mentioned above. However, it still leaves a warning icon for each eval line, which indicates “eval can be harmful” in the postman interface. Recently, I’ve found another way and post it here: Users can create a prototype object with the proper function you want in the pre-request script section, like this:

Object.prototype.sayHello = function(name){
console.log(`Hello! ${name}`);

and call that function everywhere after that. It just required a defined object, like this:

let obj = {};

Or you don’t even need the declaration of the object but use some built-in objects instead, like lodash (you pretend it has the function :smile: )


It’s working on my side. I also posted it in postman forum here


Without eval:

Define an object containing your function(s) in the collection's pre-request scripts without using let, var, etc. This attaches it to Postman's global sandbox object.

utils = {
  myFunc: function() {
    return 'hello';

Then within your request's pre-request or test script section just call the function:


Define functions as a global variables then access across all of your tests.

pm.environment.set("UTILS", `({ myFunction: (text) => console.log(text) })`)

Call the functions

let utils = eval(pm.environment.get("UTILS"))

A more elegant way consists of using the global context (not variables) in the pre-request scripts. For example, if you wish a function called myFunction to be available in any pre-request script, you can go to Edit Collection/Pre-request and set

globalThis.myFunction = function(){}

Then you can call myFunction in any pre-request script of any request inside the collection (without any stringification/evaluation of your function)


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us

©2020 All rights reserved.